{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.4"
    },
    "colab": {
      "name": "Part 08 - Introduction to Plans.ipynb",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3PT9h612lOWE",
        "colab_type": "text"
      },
      "source": [
        "# Part 8 - Plan-এর সাথে পরিচয়  (Introduction to Plans)\n",
        "\n",
        "\n",
        "### প্রসঙ্গ (Context)\n",
        "\n",
        "আমরা এখানে এমন একটি বিষয় প্রবর্তন করি যা শিল্প ফেডারেটড লার্নিং স্কেল করার জন্য অত্যন্ত গুরুত্বপূর্ণ, সেটি হলো Plan। এটি নাটকীয়ভাবে ব্যান্ডউইথের ব্যবহার হ্রাস করে, অ্যাসিনক্রোনাস স্কিমগুলির অনুমতি দেয় এবং দূরবর্তী ডিভাইসগুলিতে আরও স্বায়ত্তশাসন দেয়। পরিকল্পনার মূল ধারণাটি কাগজে পাওয়া যাবে [Towards Federated Learning at Scale: System Design](https://arxiv.org/pdf/1902.01046.pdf), তবে এটি পাইসাইফ্ট লাইব্রেরিতে আমাদের প্রয়োজনের সাথে খাপ খাইয়ে নিয়েছে।\n",
        "\n",
        "একটি পরিকল্পনা, ঠিক একটি ফাংশনের মতো torch ক্রিয়াকলাপগুলির ক্রম সংরক্ষণ করার উদ্দেশ্যে তৈরি করা হয়েছিল, তবে এটি অপারেশনগুলির এই ক্রমটি প্রত্যন্ত কর্মীদের কাছে প্রেরণ এবং এটির একটি রেফারেন্স রাখতে দেয়। এইভাবে, দূরবর্তী অবস্থান থেকে এই ক্রম গণনা করা $n$ পাঠানোর পরিবর্তে পয়েন্টারগুলির মাধ্যমে কিছু দূরবর্তী ইনপুটটিতে ক্রিয়াকলাপ $n$ পরিকল্পনার উল্লেখ এবং পয়েন্টারগুলির সাথে একক বার্তা প্রেরণের জন্য আপনার এখন যে বার্তাগুলি প্রয়োজন সেগুলি। আপনি আপনার ফাংশন সহ টেনারগুলিও সরবরাহ করতে পারেন (যা আমরা কল করি _state tensors_ ) বর্ধিত কার্যকারিতা আছে। পরিকল্পনাগুলি আপনি যে কোনও ফাংশন প্রেরণ করতে পারেন তার মতো দেখা যায়, বা এমন কোনও শ্রেণীর মতো যা প্রেরণ এবং দূরবর্তীভাবে কার্যকর করা যায়। অতএব, উচ্চ স্তরের ব্যবহারকারীদের জন্য, পরিকল্পনার ধারণাটি অদৃশ্য হয়ে যায় এবং এর পরিবর্তে একটি যাদু বৈশিষ্ট্য রয়েছে যা দূরবর্তী শ্রমিকদের সিক্যুয়ালি টর্চ ফাংশনগুলি সহ নির্বিচারে ফাংশনগুলি প্রেরণ করতে দেয়।\n",
        "\n",
        "একটি বিষয় লক্ষ্য করুন যে ফাংশনগুলির শ্রেণি যা আপনি পরিকল্পনাগুলিতে রূপান্তর করতে পারেন তা কেবল একচেটিয়াভাবে টুকরা টর্চ ক্রিয়াকলাপগুলির মধ্যে সীমাবদ্ধ। এটি যেমন নির্দিষ্ট যৌক্তিক কাঠামো বাদ দেয়  `if`, `for` এবং `while` বিবৃতি, এমনকি যদি আমরা শীঘ্রই প্রায় কাজ করতে কাজ করছি। _সম্পূর্ণরূপে সুনির্দিষ্ট হওয়ার জন্য, আপনি এগুলি ব্যবহার করতে পারেন তবে আপনার নেওয়া যৌক্তিক পথটি (প্রথমে `if` মিথ্যা এবং 5 লুপ ইন `for` উদাহরণ স্বরূপ) আপনার পরিকল্পনার প্রথম গণিতে পরবর্তী সমস্ত গণনাগুলির জন্য রাখা হবে, যা আমরা বেশিরভাগ ক্ষেত্রে এড়াতে চাই।_\n",
        "\n",
        "Authors:\n",
        "\n",
        "- Théo Ryffel - Twitter [@theoryffel](https://twitter.com/theoryffel) - GitHub: [@LaRiffle](https://github.com/LaRiffle)\n",
        "- Bobby Wagner - Twitter [@bobbyawagner](https://twitter.com/bobbyawagner) - GitHub: [@robert-wagner](https://github.com/robert-wagner)\n",
        "- Marianne Monteiro - Twitter [@hereismari](https://twitter.com/hereismari) - GitHub: [@mari-linhares](https://github.com/mari-linhares)\t"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r3AwZznDlOWT",
        "colab_type": "text"
      },
      "source": [
        "অনুবাদক:\n",
        "\n",
        "- Sourav Das - Twitter: [@adventuroussrv](https://twitter.com/adventuroussrv)\n",
        "- Mir Mohammad Jaber - Twitter: [@jabertuhin](https://twitter.com/jabertuhin)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E-RaARXFlOWW",
        "colab_type": "text"
      },
      "source": [
        "### আমদানি এবং মডেল বিশেষ উল্লেখ (Imports and model specifications)\n",
        "\n",
        "প্রথমে অফিসিয়ালগুলো আমদানি করি।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hLU-cVxGlOWb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VcNIFemXlOWr",
        "colab_type": "text"
      },
      "source": [
        "এবং এরপর পাইসাইফ্ট সম্পর্কিত নির্দিষ্টগুলি আমদানি করি একটি গুরুত্বপূর্ণ নোট সহ: **স্থানীয় কর্মী ক্লায়েন্ট কর্মী হওয়া উচিত নয়(the local worker should not be a client worker.)** *নন ক্লায়েন্ট কর্মীরা বস্তু সংরক্ষণ করতে পারে এবং একটি Plan চালানোর জন্য আমাদের এই দক্ষতার প্রয়োজন.*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4Xxnhay4lOWu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import syft as sy  # import the Pysyft library\n",
        "hook = sy.TorchHook(torch)  # hook PyTorch ie add extra functionalities \n",
        "\n",
        "# IMPORTANT: Local worker should not be a client worker\n",
        "hook.local_worker.is_client_worker = False\n",
        "\n",
        "\n",
        "server = hook.local_worker"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K5kYjlNxlOW4",
        "colab_type": "text"
      },
      "source": [
        "আমরা দূরবর্তী কর্মীদের বা ডিভাইসগুলোকে ডিফাইন করি , রেফারেন্স নিবন্ধে সরবরাহিত ধারণার সাথে সামঞ্জস্যপূর্ণ থাকতে।\n",
        "আমরা তাদের কিছু তথ্য সরবরাহ করি।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iISw9AsilOW7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x11 = torch.tensor([-1, 2.]).tag('input_data')\n",
        "x12 = torch.tensor([1, -2.]).tag('input_data2')\n",
        "x21 = torch.tensor([-1, 2.]).tag('input_data')\n",
        "x22 = torch.tensor([1, -2.]).tag('input_data2')\n",
        "\n",
        "device_1 = sy.VirtualWorker(hook, id=\"device_1\", data=(x11, x12)) \n",
        "device_2 = sy.VirtualWorker(hook, id=\"device_2\", data=(x21, x22))\n",
        "devices = device_1, device_2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3MdXVT1AlOXB",
        "colab_type": "text"
      },
      "source": [
        "### বেসিক উদাহরণ (Basic example)\n",
        "\n",
        "আসুন একটি ফাংশন ডিফাইন করি যা আমরা একটি Plan-এ রূপান্তর করতে চাই। এটি করার জন্য, এটি ফাংশন ডেফিনেশনের উপরে একটি ডেকরেটর যোগ করার মত সহজ!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "obpTg4etlOXG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "@sy.func2plan()\n",
        "def plan_double_abs(x):\n",
        "    x = x + x\n",
        "    x = torch.abs(x)\n",
        "    return x"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "biW5qP-SlOXM",
        "colab_type": "text"
      },
      "source": [
        "আসুন পরীক্ষা করে দেখি, হ্যাঁ আমাদের এখন একটি Plan আছে!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uTof1qdclOXO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "plan_double_abs"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-P6OhlI7lOXV",
        "colab_type": "text"
      },
      "source": [
        "একটি Plan ব্যবহার করতে আপনার দুটি জিনিস দরকারঃ পরিকল্পনাটি তৈরি করা (উদাহরণস্বরূপঃ আপনি ফাংশনটিতে উপস্থিত ক্রিয়াকলাপের ক্রমটি নিবন্ধ করুন) এবং এটি কোনও কর্মী/ডিভাইসে প্রেরণ করা। ভাগ্যক্রমে আপনি এটি খুব সহজেই করতে পারেন!\n",
        "\n",
        "#### একটি Plan তৈরি করা(Building a plan)\n",
        "\n",
        "একটি পরিকল্পনা তৈরি করতে আপনাকে এটিকে কিছু ডেটাতে কল করতে হবে।\n",
        "\n",
        "প্রথমে কিছু দূরবর্তী ডেটার জন্য একটি রেফারেন্স পাইঃ নেটওয়ার্কের মাধ্যমে একটি অনুরোধ প্রেরণ করা হয় এবং একটি রেফারেন্স পয়েন্টারটি ফেরত দেওয়া হয়।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i2Te-kyTlOXW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pointer_to_data = device_1.search('input_data')[0]\n",
        "pointer_to_data"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-P4Of0H1lOXa",
        "colab_type": "text"
      },
      "source": [
        "আমরা যদি Plan-কে বলি এটি অবশ্যই কার্যকর করা উচিত  দূরবর্তীভাবে `location:device_1` ডিভাইসে... আমরা সেক্ষেত্রে ত্রুটি পাবো কারণ Plan-টি এখনও নির্মিত হয়নি।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XJvXwEFJlOXc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "plan_double_abs.is_built"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9G_X78VNlOXj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Sending non-built Plan will fail\n",
        "try:\n",
        "    plan_double_abs.send(device_1)\n",
        "except RuntimeError as error:\n",
        "    print(error)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XKVsXEhulOXs",
        "colab_type": "text"
      },
      "source": [
        "একটি Plan তৈরি করতে আপনাকে কেবল Plan এর উপরে `build` কল করতে হবে এবং পরিকল্পনাটি কার্যকর করতে প্রয়োজনীয় আর্গুমেন্টগুলো পাস করুন (a.k.a কিছু ডেটা)। যখন কোনও Plam তৈরি করা হয় তখন সমস্ত কমান্ড স্থানীয় কর্মী ক্রমান্বয়ে সম্পাদন করে, এবং পরিকল্পনার দ্বারা ক্যাচ করা হয় এবং `readable_plan` অ্যাট্রিবিউট এর মধ্যে সংরক্ষণ করা হয়!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ymheYCIKlOXt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "plan_double_abs.build(torch.tensor([1., -2.]))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "06jU1RfrlOXx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "plan_double_abs.is_built"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YZqESWHflOX2",
        "colab_type": "text"
      },
      "source": [
        "আমরা যদি এখন Plan-টি পাঠানোর চেষ্টা করি তবে এটি কাজ করে!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MFnObwVolOX3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# This cell is executed successfully\n",
        "pointer_plan = plan_double_abs.send(device_1)\n",
        "pointer_plan"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EIWTRAOOlOX7",
        "colab_type": "text"
      },
      "source": [
        "ততক্ষণে টেনেসরের সাথে আমরা প্রেরিত বস্তুর একটি পয়েন্টার পাই। এখানে একে বলা হয় `PointerPlan`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xdH8PCsDlOX-",
        "colab_type": "text"
      },
      "source": [
        "একটি গুরুত্বপূর্ণ বিষয় মনে রাখবেন যে যখন একটি Plan তৈরি করা হয় তখন আমরা গণনার পূর্বে id(s) প্রি-সেট করে থাকি যেখানে result(s) সংরক্ষণ করা উচিত। এটি ইতিমধ্যে ভার্চুয়াল ফলাফলের একটি রেফারেন্স রাখতে এবং দূরবর্তী ফলাফলটি গণনা করার জন্য অপেক্ষা না করে স্থানীয় গণনা চালিয়ে যাওয়ার জন্য, অবিচ্ছিন্নভাবে কমান্ডগুলি প্রেরণের অনুমতি দেবে। একটি গুরুত্বপূর্ণ অ্যাপ্লিকেশন হলো যখন আপনার device_1 -এ একটি ব্যাচের গণনা প্রয়োজন এবং এই গণনাটি শেষের অপেক্ষা না করেই device_2 তে অন্য একটি ব্যাচ চালু করে দিতে পারি।"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rm9R37mWlOYA",
        "colab_type": "text"
      },
      "source": [
        "#### দূরবর্তীভাবে একটি Plan চালানো (Running a Plan remotely)\n",
        "\n",
        "আমরা এখন দূরবর্তী অবস্থান থেকে কিছু ডেটার পয়েন্টার দিয়ে Plan দিকে কল করে পরিকল্পনাটি চালাতে পারি। এই পরিকল্পনাটি দূর থেকে চালিত করার জন্য একটি আদেশ জারি করে, যাতে পরিকল্পনার আউটপুটটির পূর্বনির্ধারিত অবস্থানটিতে এখন ফলাফল থাকে (মনে রাখবেন আমরা গণনার আগে ফলাফলের অবস্থান নির্ধারণ করে রেখেছি)। এটির জন্য একটি যোগাযোগের রাউন্ডও প্রয়োজন।\n",
        "\n",
        "ফলাফলটি কেবল একটি পয়েন্টার, ঠিক যেমন আপনি যখন কোনও সাধারণ হুকড টর্চ ফাংশন কল করেন!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mp9lXgYslOYC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pointer_to_result = pointer_plan(pointer_to_data)\n",
        "print(pointer_to_result)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rvX1jMH2lOYK",
        "colab_type": "text"
      },
      "source": [
        "এবং আপনি কেবল মানটি আবার জিজ্ঞাসা করতে পারেন।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7lJxB05klOYM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pointer_to_result.get()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ao-YfgsClOYQ",
        "colab_type": "text"
      },
      "source": [
        "### একটি কংক্রিট উদাহরণের দিকে (Towards a concrete example)\n",
        "\n",
        "কিন্তু আমরা যা করতে চাই তা হল ডিপ এবং ফেডারেটেড লার্নিং-এ Plan প্রয়োগ করা, তাই না? সুতরাং, আপনি যেভাবে নিউরাল নেটওয়ার্ক ব্যবহার করে কাজ করতে ইচ্ছুক, তেমন একটু জটিল একটি উদাহরণ দেখা যাক।\n",
        "খেয়াল করুন যে আমরা এখন একটি ক্লাসকে Plan-এ রূপান্তর করছি। এটি করার জন্য, আমরা আমাদের ক্লাসকে sy.Plan থেকে inherit করবো(nn.Module এর থেকে inherite-এর পরিবর্তে)।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s8RUjN-3lOYR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Net(sy.Plan):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.fc1 = nn.Linear(2, 3)\n",
        "        self.fc2 = nn.Linear(3, 2)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = self.fc2(x)\n",
        "        return F.log_softmax(x, dim=0)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BvO4_2HflOYW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "net = Net()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PZxDAkg0lOYa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "net"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eIajLUuLlOYh",
        "colab_type": "text"
      },
      "source": [
        "আসুন কিছু মক ডেটা ব্যবহার করে Plan-টি তৈরি করি।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aD5kauFAlOYj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "net.build(torch.tensor([1., 2.]))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HdaK_m_llOYp",
        "colab_type": "text"
      },
      "source": [
        "আমরা এখন পরিকল্পনাটি দূরবর্তী শ্রমিকের কাছে প্রেরণ করি"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8JnHuAjSlOYr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pointer_to_net = net.send(device_1)\n",
        "pointer_to_net"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2pdd2qsvlOYv",
        "colab_type": "text"
      },
      "source": [
        "আসুন কিছু দূরবর্তী ডেটা উদ্ধার করি"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8vbzwazPlOYw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pointer_to_data = device_1.search('input_data')[0]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "naqGSvQZlOY1",
        "colab_type": "text"
      },
      "source": [
        "তারপরে, সিনট্যাক্স সাধারণ দূরবর্তী সিকুয়েনশিয়াল এক্সিকিউশনের মতো, ঠিক যেমন স্থানীয়ভাবে এক্সিকিউট হতো। ক্লাসিক রিমোট এক্সিকিউশনের সাথে তুলনা করলে প্রতিটি এক্সিকিউশনে একটি যোগাযোগ রাউন্ড থাকে।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yBQyt8TRlOY3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pointer_to_result = pointer_to_net(pointer_to_data)\n",
        "pointer_to_result"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hqbntbT9lOY7",
        "colab_type": "text"
      },
      "source": [
        "এবং আমরা যথারীতি ফলাফল পাচ্ছি।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QpBbio-plOY8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pointer_to_result.get()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SeCqmDkQlOZB",
        "colab_type": "text"
      },
      "source": [
        "Et voilà! আমরা দেখেছি কীভাবে স্থানীয় কর্মী (বা সার্ভার) এবং দূরবর্তী ডিভাইসগুলির মধ্যে যোগাযোগ দারুনভাবে হ্রাস করতে পারে!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tXQPuj8WlOZC",
        "colab_type": "text"
      },
      "source": [
        "### কর্মীদের মধ্যে স্যুইচ করুন (Switch between workers)\n",
        "\n",
        "একটি প্রধান বৈশিষ্ট্য যা আমরা রাখতে চাই তা হলো বেশ কয়েকটি শ্রমিকের জন্য একই Plan ব্যবহার করা, আমরা যে ডেটা বিবেচনা করছি তা দূরবর্তী ব্যাচের উপর নির্ভর করে পরিবর্তন করব।\n",
        "বিশেষত, প্রতিবার কর্মী পরিবর্তন করার পরে আমরা Plan-টি পুনর্নির্মাণ করতে চাই না। আসুন দেখি আমরা কিভাবে এটি করি, আমাদের ছোট নেটওয়ার্কের সাথে পূর্ববর্তী উদাহরণটি ব্যবহার করে।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WxDz54IxlOZE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Net(sy.Plan):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.fc1 = nn.Linear(2, 3)\n",
        "        self.fc2 = nn.Linear(3, 2)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = self.fc2(x)\n",
        "        return F.log_softmax(x, dim=0)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5g6A7uSzlOZM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "net = Net()\n",
        "\n",
        "# Build plan\n",
        "net.build(torch.tensor([1., 2.]))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dm7iGw-glOZQ",
        "colab_type": "text"
      },
      "source": [
        "এখানে আমাদের নেয়া মূল পদক্ষেপগুলো দেয়া হলো"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-ZBvZj_JlOZU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pointer_to_net_1 = net.send(device_1)\n",
        "pointer_to_data = device_1.search('input_data')[0]\n",
        "pointer_to_result = pointer_to_net_1(pointer_to_data)\n",
        "pointer_to_result.get()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kTfPX-mllOZb",
        "colab_type": "text"
      },
      "source": [
        "এবং প্রকৃতপক্ষে আপনি একই Plan থেকে অন্যান্য PointerPlans তৈরি করতে পারেন, সুতরাং রিমোটলি অন্য ডিভাইসে Plan চালানোর জন্য সিন্ট্যাক্স একই থাকবে।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mUb-zBTclOZe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pointer_to_net_2 = net.send(device_2)\n",
        "pointer_to_data = device_2.search('input_data')[0]\n",
        "pointer_to_result = pointer_to_net_2(pointer_to_data)\n",
        "pointer_to_result.get()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oPj995WOlOZi",
        "colab_type": "text"
      },
      "source": [
        "> দ্রষ্টব্য: বর্তমানে, Plan ক্লাসের সাথে আপনি কেবল একটি মেথড ব্যবহার করতে পারেন এবং আপনাকে এটির নাম \"forward\" রাখতে হবে।"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OJQgBRGklOZj",
        "colab_type": "text"
      },
      "source": [
        "### স্বয়ংক্রিয়ভাবে Plan তৈরি করা যেগুলো ফাংশন (Automatically building plans that are functions)\n",
        "\n",
        "ফাংশনের জন্য (`@` `sy.func2plan`) আমরা build কে কল না করেই স্বয়ংক্রিয়ভাবে Plan তৈরি করতে পারি, প্রকৃতপক্ষে Plan সৃষ্টি হওয়ার সময়ই তৈরি হয়ে যায়।\n",
        "\n",
        "এই কার্যকারিতাটি পেতে হলে, Plan তৈরি করার সময় আমাদের যে একটি জিনিস পরিবর্তন করতে হবে তা হলো args_shape decorator আর্গুমেন্ট যুক্তকরা। যা কি-না প্রতিটা আর্গুমেন্টের শেপ সম্বলিৎ একটা লিস্ট হবে।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "14hmSnrglOZk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "@sy.func2plan(args_shape=[(-1, 1)])\n",
        "def plan_double_abs(x):\n",
        "    x = x + x\n",
        "    x = torch.abs(x)\n",
        "    return x\n",
        "\n",
        "plan_double_abs.is_built"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p6AYVVEYlOZp",
        "colab_type": "text"
      },
      "source": [
        "Plan-টা তৈরির জন্য প্রদত্ত আকারের মক টেন্সরগুলো তৈরি করতে `args_shape` প্যারামিটারটি অভ্যন্তরীণভাবে ব্যবহৃত হয়।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yVpb_tWElOZq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "@sy.func2plan(args_shape=[(1, 2), (-1, 2)])\n",
        "def plan_sum_abs(x, y):\n",
        "    s = x + y\n",
        "    return torch.abs(s)\n",
        "\n",
        "plan_sum_abs.is_built"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W5c-KdwqlOZt",
        "colab_type": "text"
      },
      "source": [
        "আপনি ফাংশনগুলোতে স্টেটের উপাদানগুলি সরবরাহ করতে পারেন!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0blID-f-lOZu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "@sy.func2plan(args_shape=[(1,)], state=(torch.tensor([1]), ))\n",
        "def plan_abs(x, state):\n",
        "    bias, = state.read()\n",
        "    x = x.abs()\n",
        "    return x + bias"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P_qLpYxflOZz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pointer_plan = plan_abs.send(device_1)\n",
        "x_ptr = torch.tensor([-1, 0]).send(device_1)\n",
        "p = pointer_plan(x_ptr)\n",
        "p.get()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XvYQ-i4clOZ4",
        "colab_type": "text"
      },
      "source": [
        "এ সম্পর্কে আরও জানার জন্য, টিউটোরিয়াল Part-8 Bis এ জানতে পারবেন আমরা কিভাবে Plans এর সাথে প্রোটোকল ব্যবহার করি।"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NVX4d61NlOZ5",
        "colab_type": "text"
      },
      "source": [
        "### গিটহাবে পাইসিফ্ট কে স্টার দিন (Star PySyft on GitHub)\n",
        "\n",
        "আমাদের সম্প্রদায়কে সাহায্য করার সবচেয়ে সহজ উপায় হল রিপোসিটোরি গুলোতে ষ্টার করা\n",
        " এটি আমরা যে অসাধারণ সরঞ্জামগুলি তৈরি করছি তার সচেতনতা বাড়াতে সহায়তা করে।\n",
        "\n",
        "- [Star PySyft](https://github.com/OpenMined/PySyft)\n",
        "\n",
        "### গিটহাবে আমাদের টিউটোরিয়ালগুলি চয়ন করুন (Pick our tutorials on GitHub!)\n",
        "\n",
        "ফেডারেটেড এবং প্রাইভেসি-প্রিজারভেভিং লার্নিংয়ের চেহারা কেমন হওয়া উচিত এবং আমরা এটির জন্য ইটগুলি কীভাবে তৈরি করছি সে সম্পর্কে আরও ভাল ধারণা পেতে আমরা সত্যিই দুর্দান্ত টিউটোরিয়াল তৈরি করেছি।\n",
        "\n",
        "- [Checkout the PySyft tutorials](https://github.com/OpenMined/PySyft/tree/master/examples/tutorials)\n",
        "\n",
        "\n",
        "### আমাদের স্ল্যাক যোগ দিন (Join our Slack!)\n",
        "\n",
        "সর্বশেষতম অগ্রগতিতে আপ টু ডেট রাখার সর্বোত্তম উপায় হ'ল আমাদের সম্প্রদায়ে যোগদান করা! আপনি ফর্মটি পূরণ করে এটি করতে পারেন\n",
        "\n",
        "- [Join slack.openmined.org](http://slack.openmined.org)\n",
        "\n",
        "### একটি কোড প্রকল্পে যোগদান করুন! (Join a Code Project!)\n",
        "\n",
        "আমাদের সম্প্রদায়ে অবদান রাখার সর্বোত্তম উপায় হ'ল কোড অবদানকারী হয়ে উঠুন! আপনি যদি \"ওয়ান অফ\" মিনি-প্রকল্পগুলি শুরু করতে চান আপনি পাই সাইফ্ট গিটহাব ইস্যু পৃষ্ঠাতে এবং চিহ্নিত বিষয়গুলির জন্য অনুসন্ধান করতে পারেন `Good First Issue`.\n",
        "\n",
        "- [Good First Issue Tickets](https://github.com/OpenMined/PySyft/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n",
        "\n",
        "### দান করুন (Donate)\n",
        "\n",
        "আপনার যদি আমাদের কোডবেসে অবদান রাখার সময় না থাকে তবে তবুও সমর্থন দিতে চান, আপনি আমাদের ওপেন কালেক্টিভেরও Backer হয়ে উঠতে পারেন। সমস্ত অনুদান আমাদের ওয়েব হোস্টিং এবং অন্যান্য সম্প্রদায় ব্যয় যেমন হ্যাকাথনস এবং মেটআপগুলির (hackathons and meetups!) দিকে যায়!\n",
        "\n",
        "- [Donate through OpenMined's Open Collective Page](https://opencollective.com/openmined)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ww6udGW-lOZ6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}